protected CacheControl CacheControl()

{
}

public CacheControl cachePrivate()

{
    this.cachePrivate = true;
    return this;
}

public CacheControl cachePublic()

{
    this.cachePublic = true;
    return this;
}

public static CacheControl empty()

{
    return new CacheControl();
}

@Nullable public String getHeaderValue()

{
    String headerValue = toHeaderValue();
    return (StringUtils.hasText(headerValue) ? headerValue : null);
}

public static CacheControl maxAge(long maxAge, TimeUnit unit)

{
    return maxAge(Duration.ofSeconds(unit.toSeconds(maxAge)));
}

public static CacheControl maxAge(Duration maxAge)

{
    CacheControl cc = new CacheControl();
    cc.maxAge = maxAge;
    return cc;
}

public CacheControl mustRevalidate()

{
    this.mustRevalidate = true;
    return this;
}

public static CacheControl noCache()

{
    CacheControl cc = new CacheControl();
    cc.noCache = true;
    return cc;
}

public static CacheControl noStore()

{
    CacheControl cc = new CacheControl();
    cc.noStore = true;
    return cc;
}

public CacheControl noTransform()

{
    this.noTransform = true;
    return this;
}

public CacheControl proxyRevalidate()

{
    this.proxyRevalidate = true;
    return this;
}

public CacheControl sMaxAge(long sMaxAge, TimeUnit unit)

{
    return sMaxAge(Duration.ofSeconds(unit.toSeconds(sMaxAge)));
}

public CacheControl sMaxAge(Duration sMaxAge)

{
    this.sMaxAge = sMaxAge;
    return this;
}

public CacheControl staleIfError(long staleIfError, TimeUnit unit)

{
    return staleIfError(Duration.ofSeconds(unit.toSeconds(staleIfError)));
}

public CacheControl staleIfError(Duration staleIfError)

{
    this.staleIfError = staleIfError;
    return this;
}

public CacheControl staleWhileRevalidate(long staleWhileRevalidate, TimeUnit unit)

{
    return staleWhileRevalidate(Duration.ofSeconds(unit.toSeconds(staleWhileRevalidate)));
}

public CacheControl staleWhileRevalidate(Duration staleWhileRevalidate)

{
    this.staleWhileRevalidate = staleWhileRevalidate;
    return this;
}

@Override public String toString()

{
    return "CacheControl [" + toHeaderValue() + "]";
}

Builder

public static Builder builder(String type)

{
    return new BuilderImpl(type);
}

public static ContentDisposition empty()

{
    return new ContentDisposition("", null, null, null, null, null, null, null);
}

@Override public boolean equals(@JavaAnnotationCall(Nullable,) Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof ContentDisposition)) {
        return false;
    } 
    ContentDisposition otherCd = (ContentDisposition)other;
    return (ObjectUtils.nullSafeEquals(this.type, otherCd.type) && ObjectUtils.nullSafeEquals(this.name, otherCd.name) && ObjectUtils.nullSafeEquals(this.filename, otherCd.filename) && ObjectUtils.nullSafeEquals(this.charset, otherCd.charset) && ObjectUtils.nullSafeEquals(this.size, otherCd.size) && ObjectUtils.nullSafeEquals(this.creationDate, otherCd.creationDate) && ObjectUtils.nullSafeEquals(this.modificationDate, otherCd.modificationDate) && ObjectUtils.nullSafeEquals(this.readDate, otherCd.readDate));
}

@Nullable public Charset getCharset()

{
    return this.charset;
}

@Nullable public ZonedDateTime getCreationDate()

{
    return this.creationDate;
}

@Nullable public String getFilename()

{
    return this.filename;
}

@Nullable public ZonedDateTime getModificationDate()

{
    return this.modificationDate;
}

@Nullable public String getName()

{
    return this.name;
}

@Nullable public ZonedDateTime getReadDate()

{
    return this.readDate;
}

@Nullable public Long getSize()

{
    return this.size;
}

@Nullable public String getType()

{
    return this.type;
}

@Override public int hashCode()

{
    int result = ObjectUtils.nullSafeHashCode(this.type);
    result = 31 * result + ObjectUtils.nullSafeHashCode(this.name);
    result = 31 * result + ObjectUtils.nullSafeHashCode(this.filename);
    result = 31 * result + ObjectUtils.nullSafeHashCode(this.charset);
    result = 31 * result + ObjectUtils.nullSafeHashCode(this.size);
    result = 31 * result + (this.creationDate != null ? this.creationDate.hashCode() : 0);
    result = 31 * result + (this.modificationDate != null ? this.modificationDate.hashCode() : 0);
    result = 31 * result + (this.readDate != null ? this.readDate.hashCode() : 0);
    return result;
}

public static ContentDisposition parse(String contentDisposition)

{
    List<String> parts = tokenize(contentDisposition);
    String type = parts.get(0);
    String name = null;
    String filename = null;
    Charset charset = null;
    Long size = null;
    ZonedDateTime creationDate = null;
    ZonedDateTime modificationDate = null;
    ZonedDateTime readDate = null;
    for (int i = 1; i < parts.size(); i++) {
        String part = parts.get(i);
        int eqIndex = part.indexOf('=');
        if (eqIndex != -1) {
            String attribute = part.substring(0, eqIndex);
            String value = (part.startsWith("\"", eqIndex + 1) && part.endsWith("\"") ? part.substring(eqIndex + 2, part.length() - 1) : part.substring(eqIndex + 1));
            if (attribute.equals("name")) {
                name = value;
            } else if (attribute.equals("filename*")) {
                int idx1 = value.indexOf('\'');
                int idx2 = value.indexOf('\'', idx1 + 1);
                if (idx1 != -1 && idx2 != -1) {
                    charset = Charset.forName(value.substring(0, idx1));
                    Assert.isTrue(UTF_8.equals(charset) || ISO_8859_1.equals(charset), "Charset should be UTF-8 or ISO-8859-1");
                    filename = decodeFilename(value.substring(idx2 + 1), charset);
                } else {
                    filename = decodeFilename(value, StandardCharsets.US_ASCII);
                }
            } else if (attribute.equals("filename") && (filename == null)) {
                filename = value;
            } else if (attribute.equals("size")) {
                size = Long.parseLong(value);
            } else if (attribute.equals("creation-date")) {
                try {
                    creationDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME);
                } catch (DateTimeParseException ex) {
                }
            } else if (attribute.equals("modification-date")) {
                try {
                    modificationDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME);
                } catch (DateTimeParseException ex) {
                }
            } else if (attribute.equals("read-date")) {
                try {
                    readDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME);
                } catch (DateTimeParseException ex) {
                }
            } 
        } else {
            throw new IllegalArgumentException("Invalid content disposition format");
        }
    }
    return new ContentDisposition(type, name, filename, charset, size, creationDate, modificationDate, readDate);
}

@Override public String toString()

{
    StringBuilder sb = new StringBuilder();
    if (this.type != null) {
        sb.append(this.type);
    } 
    if (this.name != null) {
        sb.append("; name=\"");
        sb.append(this.name).append('\"');
    } 
    if (this.filename != null) {
        if (this.charset == null || StandardCharsets.US_ASCII.equals(this.charset)) {
            sb.append("; filename=\"");
            sb.append(this.filename).append('\"');
        } else {
            sb.append("; filename*=");
            sb.append(encodeFilename(this.filename, this.charset));
        }
    } 
    if (this.size != null) {
        sb.append("; size=");
        sb.append(this.size);
    } 
    if (this.creationDate != null) {
        sb.append("; creation-date=\"");
        sb.append(RFC_1123_DATE_TIME.format(this.creationDate));
        sb.append('\"');
    } 
    if (this.modificationDate != null) {
        sb.append("; modification-date=\"");
        sb.append(RFC_1123_DATE_TIME.format(this.modificationDate));
        sb.append('\"');
    } 
    if (this.readDate != null) {
        sb.append("; read-date=\"");
        sb.append(RFC_1123_DATE_TIME.format(this.readDate));
        sb.append('\"');
    } 
    return sb.toString();
}

public HttpCookie HttpCookie(String name, @JavaAnnotationCall(Nullable,) String value)

{
    Assert.hasLength(name, "'name' is required and must not be empty.");
    this.name = name;
    this.value = (value != null ? value : "");
}

@Override public boolean equals(@JavaAnnotationCall(Nullable,) Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HttpCookie)) {
        return false;
    } 
    HttpCookie otherCookie = (HttpCookie)other;
    return (this.name.equalsIgnoreCase(otherCookie.getName()));
}

public String getName()

{
    return this.name;
}

public String getValue()

{
    return this.value;
}

@Override public int hashCode()

{
    return this.name.hashCode();
}

@Override public String toString()

{
    return this.name + '=' + this.value;
}

public static final HttpEntity<?> EMPTY

protected HttpEntity HttpEntity()

{
    this(null, null);
}

public HttpEntity HttpEntity(T body)

{
    this(body, null);
}

public HttpEntity HttpEntity(MultiValueMap<String, String> headers)

{
    this(null, headers);
}

public HttpEntity HttpEntity(@JavaAnnotationCall(Nullable,) T body, @JavaAnnotationCall(Nullable,) MultiValueMap<String, String> headers)

{
    this.body = body;
    HttpHeaders tempHeaders = new HttpHeaders();
    if (headers != null) {
        tempHeaders.putAll(headers);
    } 
    this.headers = HttpHeaders.readOnlyHttpHeaders(tempHeaders);
}

@Override public boolean equals(@JavaAnnotationCall(Nullable,) Object other)

{
    if (this == other) {
        return true;
    } 
    if (other == null || other.getClass() != getClass()) {
        return false;
    } 
    HttpEntity<?> otherEntity = (HttpEntity<?>)other;
    return (ObjectUtils.nullSafeEquals(this.headers, otherEntity.headers) && ObjectUtils.nullSafeEquals(this.body, otherEntity.body));
}

@Nullable public T getBody()

{
    return this.body;
}

public HttpHeaders getHeaders()

{
    return this.headers;
}

public boolean hasBody()

{
    return (this.body != null);
}

@Override public int hashCode()

{
    return (ObjectUtils.nullSafeHashCode(this.headers) * 29 + ObjectUtils.nullSafeHashCode(this.body));
}

@Override public String toString()

{
    StringBuilder builder = new StringBuilder("<");
    if (this.body != null) {
        builder.append(this.body);
        builder.append(',');
    } 
    builder.append(this.headers);
    builder.append('>');
    return builder.toString();
}

public static final String ACCEPT

public static final String ACCEPT_CHARSET

public static final String ACCEPT_ENCODING

public static final String ACCEPT_LANGUAGE

public static final String ACCEPT_RANGES

public static final String ACCESS_CONTROL_ALLOW_CREDENTIALS

public static final String ACCESS_CONTROL_ALLOW_HEADERS

public static final String ACCESS_CONTROL_ALLOW_METHODS

public static final String ACCESS_CONTROL_ALLOW_ORIGIN

public static final String ACCESS_CONTROL_EXPOSE_HEADERS

public static final String ACCESS_CONTROL_MAX_AGE

public static final String ACCESS_CONTROL_REQUEST_HEADERS

public static final String ACCESS_CONTROL_REQUEST_METHOD

public static final String AGE

public static final String ALLOW

public static final String AUTHORIZATION

public static final String CACHE_CONTROL

public static final String CONNECTION

public static final String CONTENT_DISPOSITION

public static final String CONTENT_ENCODING

public static final String CONTENT_LANGUAGE

public static final String CONTENT_LENGTH

public static final String CONTENT_LOCATION

public static final String CONTENT_RANGE

public static final String CONTENT_TYPE

public static final String COOKIE

public static final String DATE

public static final HttpHeaders EMPTY

public static final String ETAG

public static final String EXPECT

public static final String EXPIRES

public static final String FROM

public static final String HOST

public HttpHeaders HttpHeaders()

{
    this(CollectionUtils.toMultiValueMap(new LinkedCaseInsensitiveMap<>(8, Locale.ENGLISH)));
}

public HttpHeaders HttpHeaders(MultiValueMap<String, String> headers)

{
    Assert.notNull(headers, "MultiValueMap must not be null");
    this.headers = headers;
}

public static final String IF_MATCH

public static final String IF_MODIFIED_SINCE

public static final String IF_NONE_MATCH

public static final String IF_RANGE

public static final String IF_UNMODIFIED_SINCE

public static final String LAST_MODIFIED

public static final String LINK

public static final String LOCATION

public static final String MAX_FORWARDS

public static final String ORIGIN

public static final String PRAGMA

public static final String PROXY_AUTHENTICATE

public static final String PROXY_AUTHORIZATION

public static final String RANGE

public static final String REFERER

public static final String RETRY_AFTER

public static final String SERVER

public static final String SET_COOKIE

public static final String SET_COOKIE2

public static final String TE

public static final String TRAILER

public static final String TRANSFER_ENCODING

public static final String UPGRADE

public static final String USER_AGENT

public static final String VARY

public static final String VIA

public static final String WARNING

public static final String WWW_AUTHENTICATE

@Override public void add(String headerName, @JavaAnnotationCall(Nullable,) String headerValue)

{
    this.headers.add(headerName, headerValue);
}

@Override public void addAll(String key, List<?> values)

{
    this.headers.addAll(key, values);
}

@Override public void addAll(MultiValueMap<String, String> values)

{
    this.headers.addAll(values);
}

@Override public void clear()

{
    this.headers.clear();
}

@Override public boolean containsKey(Object key)

{
    return this.headers.containsKey(key);
}

@Override public boolean containsValue(Object value)

{
    return this.headers.containsValue(value);
}

public static String encodeBasicAuth(String username, String password, @JavaAnnotationCall(Nullable,) Charset charset)

{
    Assert.notNull(username, "Username must not be null");
    Assert.doesNotContain(username, ":", "Username must not contain a colon");
    Assert.notNull(password, "Password must not be null");
    if (charset == null) {
        charset = StandardCharsets.ISO_8859_1;
    } 
    CharsetEncoder encoder = charset.newEncoder();
    if (!encoder.canEncode(username) || !encoder.canEncode(password)) {
        throw new IllegalArgumentException("Username or password contains characters that cannot be encoded to " + charset.displayName());
    } 
    String credentialsString = username + ":" + password;
    byte[] encodedBytes = Base64.getEncoder().encode(credentialsString.getBytes(charset));
    return new String(encodedBytes, charset);
}

@Override public Set<Entry<String, List<String>>> entrySet()

{
    return this.headers.entrySet();
}

@Override public boolean equals(@JavaAnnotationCall(Nullable,) Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HttpHeaders)) {
        return false;
    } 
    HttpHeaders otherHeaders = (HttpHeaders)other;
    return this.headers.equals(otherHeaders.headers);
}

public static String formatHeaders(MultiValueMap<String, String> headers)

{
    return headers.entrySet().stream().map(entry -> {
        List<String> values = entry.getValue();
        return entry.getKey() + ":" + (values.size() == 1 ? "\"" + values.get(0) + "\"" : values.stream().map(s -> "\"" + s + "\"").collect(Collectors.joining(", ")));
    }).collect(Collectors.joining(", ", "[", "]"));
}

@Override @Nullable public List<String> get(Object key)

{
    return this.headers.get(key);
}

public List<MediaType> getAccept()

{
    return MediaType.parseMediaTypes(get(ACCEPT));
}

public List<Charset> getAcceptCharset()

{
    String value = getFirst(ACCEPT_CHARSET);
    if (value != null) {
        String[] tokens = StringUtils.tokenizeToStringArray(value, ",");
        List<Charset> result = new ArrayList<>(tokens.length);
        for (String token: tokens) {
            int paramIdx = token.indexOf(';');
            String charsetName;
            if (paramIdx == -1) {
                charsetName = token;
            } else {
                charsetName = token.substring(0, paramIdx);
            }
            if (!charsetName.equals("*")) {
                result.add(Charset.forName(charsetName));
            } 
        }
        return result;
    } else {
        return Collections.emptyList();
    }
}

public List<Locale.LanguageRange> getAcceptLanguage()

{
    String value = getFirst(ACCEPT_LANGUAGE);
    return (StringUtils.hasText(value) ? Locale.LanguageRange.parse(value) : Collections.emptyList());
}

public List<Locale> getAcceptLanguageAsLocales()

{
    List<Locale.LanguageRange> ranges = getAcceptLanguage();
    if (ranges.isEmpty()) {
        return Collections.emptyList();
    } 
    return ranges.stream().map(range -> Locale.forLanguageTag(range.getRange())).filter(locale -> StringUtils.hasText(locale.getDisplayName())).collect(Collectors.toList());
}

public boolean getAccessControlAllowCredentials()

{
    return Boolean.parseBoolean(getFirst(ACCESS_CONTROL_ALLOW_CREDENTIALS));
}

public List<String> getAccessControlAllowHeaders()

{
    return getValuesAsList(ACCESS_CONTROL_ALLOW_HEADERS);
}

public List<HttpMethod> getAccessControlAllowMethods()

{
    List<HttpMethod> result = new ArrayList<>();
    String value = getFirst(ACCESS_CONTROL_ALLOW_METHODS);
    if (value != null) {
        String[] tokens = StringUtils.tokenizeToStringArray(value, ",");
        for (String token: tokens) {
            HttpMethod resolved = HttpMethod.resolve(token);
            if (resolved != null) {
                result.add(resolved);
            } 
        }
    } 
    return result;
}

@Nullable public String getAccessControlAllowOrigin()

{
    return getFieldValues(ACCESS_CONTROL_ALLOW_ORIGIN);
}

public List<String> getAccessControlExposeHeaders()

{
    return getValuesAsList(ACCESS_CONTROL_EXPOSE_HEADERS);
}

public long getAccessControlMaxAge()

{
    String value = getFirst(ACCESS_CONTROL_MAX_AGE);
    return (value != null ? Long.parseLong(value) : -1);
}

public List<String> getAccessControlRequestHeaders()

{
    return getValuesAsList(ACCESS_CONTROL_REQUEST_HEADERS);
}

@Nullable public HttpMethod getAccessControlRequestMethod()

{
    return HttpMethod.resolve(getFirst(ACCESS_CONTROL_REQUEST_METHOD));
}

public Set<HttpMethod> getAllow()

{
    String value = getFirst(ALLOW);
    if (StringUtils.hasLength(value)) {
        String[] tokens = StringUtils.tokenizeToStringArray(value, ",");
        List<HttpMethod> result = new ArrayList<>(tokens.length);
        for (String token: tokens) {
            HttpMethod resolved = HttpMethod.resolve(token);
            if (resolved != null) {
                result.add(resolved);
            } 
        }
        return EnumSet.copyOf(result);
    } else {
        return EnumSet.noneOf(HttpMethod.class);
    }
}

@Nullable public String getCacheControl()

{
    return getFieldValues(CACHE_CONTROL);
}

public List<String> getConnection()

{
    return getValuesAsList(CONNECTION);
}

public ContentDisposition getContentDisposition()

{
    String contentDisposition = getFirst(CONTENT_DISPOSITION);
    if (contentDisposition != null) {
        return ContentDisposition.parse(contentDisposition);
    } 
    return ContentDisposition.empty();
}

@Nullable public Locale getContentLanguage()

{
    return getValuesAsList(CONTENT_LANGUAGE).stream().findFirst().map(Locale::forLanguageTag).orElse(null);
}

public long getContentLength()

{
    String value = getFirst(CONTENT_LENGTH);
    return (value != null ? Long.parseLong(value) : -1);
}

@Nullable public MediaType getContentType()

{
    String value = getFirst(CONTENT_TYPE);
    return (StringUtils.hasLength(value) ? MediaType.parseMediaType(value) : null);
}

public long getDate()

{
    return getFirstDate(DATE);
}

@Nullable public String getETag()

{
    return getFirst(ETAG);
}

protected List<String> getETagValuesAsList(String headerName)

{
    List<String> values = get(headerName);
    if (values != null) {
        List<String> result = new ArrayList<>();
        for (String value: values) {
            if (value != null) {
                Matcher matcher = ETAG_HEADER_VALUE_PATTERN.matcher(value);
                while (matcher.find()) {
                    if ("*".equals(matcher.group())) {
                        result.add(matcher.group());
                    } else {
                        result.add(matcher.group(1));
                    }
                }
                if (result.isEmpty()) {
                    throw new IllegalArgumentException("Could not parse header '" + headerName + "' with value '" + value + "'");
                } 
            } 
        }
        return result;
    } 
    return Collections.emptyList();
}

public long getExpires()

{
    return getFirstDate(EXPIRES, false);
}

@Nullable protected String getFieldValues(String headerName)

{
    List<String> headerValues = get(headerName);
    return (headerValues != null ? toCommaDelimitedString(headerValues) : null);
}

@Override @Nullable public String getFirst(String headerName)

{
    return this.headers.getFirst(headerName);
}

public long getFirstDate(String headerName)

{
    return getFirstDate(headerName, true);
}

@Nullable public ZonedDateTime getFirstZonedDateTime(String headerName)

{
    return getFirstZonedDateTime(headerName, true);
}

@Nullable public InetSocketAddress getHost()

{
    String value = getFirst(HOST);
    if (value == null) {
        return null;
    } 
    String host = null;
    int port = 0;
    int separator = (value.startsWith("[") ? value.indexOf(':', value.indexOf(']')) : value.lastIndexOf(':'));
    if (separator != -1) {
        host = value.substring(0, separator);
        String portString = value.substring(separator + 1);
        try {
            port = Integer.parseInt(portString);
        } catch (NumberFormatException ex) {
        }
    } 
    if (host == null) {
        host = value;
    } 
    return InetSocketAddress.createUnresolved(host, port);
}

public List<String> getIfMatch()

{
    return getETagValuesAsList(IF_MATCH);
}

public long getIfModifiedSince()

{
    return getFirstDate(IF_MODIFIED_SINCE, false);
}

public List<String> getIfNoneMatch()

{
    return getETagValuesAsList(IF_NONE_MATCH);
}

public long getIfUnmodifiedSince()

{
    return getFirstDate(IF_UNMODIFIED_SINCE, false);
}

public long getLastModified()

{
    return getFirstDate(LAST_MODIFIED, false);
}

@Nullable public URI getLocation()

{
    String value = getFirst(LOCATION);
    return (value != null ? URI.create(value) : null);
}

public List<String> getOrEmpty(Object headerName)

{
    List<String> values = get(headerName);
    return (values != null ? values : Collections.emptyList());
}

@Nullable public String getOrigin()

{
    return getFirst(ORIGIN);
}

@Nullable public String getPragma()

{
    return getFirst(PRAGMA);
}

public List<HttpRange> getRange()

{
    String value = getFirst(RANGE);
    return HttpRange.parseRanges(value);
}

@Nullable public String getUpgrade()

{
    return getFirst(UPGRADE);
}

public List<String> getValuesAsList(String headerName)

{
    List<String> values = get(headerName);
    if (values != null) {
        List<String> result = new ArrayList<>();
        for (String value: values) {
            if (value != null) {
                Collections.addAll(result, StringUtils.tokenizeToStringArray(value, ","));
            } 
        }
        return result;
    } 
    return Collections.emptyList();
}

public List<String> getVary()

{
    return getValuesAsList(VARY);
}

@Override public int hashCode()

{
    return this.headers.hashCode();
}

@Override public boolean isEmpty()

{
    return this.headers.isEmpty();
}

@Override public Set<String> keySet()

{
    return this.headers.keySet();
}

@Override public List<String> put(String key, List<String> value)

{
    return this.headers.put(key, value);
}

@Override public void putAll(Map<?, ?> map)

{
    this.headers.putAll(map);
}

public static HttpHeaders readOnlyHttpHeaders(HttpHeaders headers)

{
    Assert.notNull(headers, "HttpHeaders must not be null");
    if (headers instanceof ReadOnlyHttpHeaders) {
        return headers;
    } else {
        return new ReadOnlyHttpHeaders(headers);
    }
}

@Override public List<String> remove(Object key)

{
    return this.headers.remove(key);
}

@Override public void set(String headerName, @JavaAnnotationCall(Nullable,) String headerValue)

{
    this.headers.set(headerName, headerValue);
}

public void setAccept(List<MediaType> acceptableMediaTypes)

{
    set(ACCEPT, MediaType.toString(acceptableMediaTypes));
}

public void setAcceptCharset(List<Charset> acceptableCharsets)

{
    StringJoiner joiner = new StringJoiner(", ");
    for (Charset charset: acceptableCharsets) {
        joiner.add(charset.name().toLowerCase(Locale.ENGLISH));
    }
    set(ACCEPT_CHARSET, joiner.toString());
}

public void setAcceptLanguage(List<Locale.LanguageRange> languages)

{
    Assert.notNull(languages, "LanguageRange List must not be null");
    DecimalFormat decimal = new DecimalFormat("0.0", DECIMAL_FORMAT_SYMBOLS);
    List<String> values = languages.stream().map(range -> range.getWeight() == Locale.LanguageRange.MAX_WEIGHT ? range.getRange() : range.getRange() + ";q=" + decimal.format(range.getWeight())).collect(Collectors.toList());
    set(ACCEPT_LANGUAGE, toCommaDelimitedString(values));
}

public void setAcceptLanguageAsLocales(List<Locale> locales)

{
    setAcceptLanguage(locales.stream().map(locale -> new Locale.LanguageRange(locale.toLanguageTag())).collect(Collectors.toList()));
}

public void setAccessControlAllowCredentials(boolean allowCredentials)

{
    set(ACCESS_CONTROL_ALLOW_CREDENTIALS, Boolean.toString(allowCredentials));
}

public void setAccessControlAllowHeaders(List<String> allowedHeaders)

{
    set(ACCESS_CONTROL_ALLOW_HEADERS, toCommaDelimitedString(allowedHeaders));
}

public void setAccessControlAllowMethods(List<HttpMethod> allowedMethods)

{
    set(ACCESS_CONTROL_ALLOW_METHODS, StringUtils.collectionToCommaDelimitedString(allowedMethods));
}

public void setAccessControlAllowOrigin(@JavaAnnotationCall(Nullable,) String allowedOrigin)

{
    setOrRemove(ACCESS_CONTROL_ALLOW_ORIGIN, allowedOrigin);
}

public void setAccessControlExposeHeaders(List<String> exposedHeaders)

{
    set(ACCESS_CONTROL_EXPOSE_HEADERS, toCommaDelimitedString(exposedHeaders));
}

public void setAccessControlMaxAge(Duration maxAge)

{
    set(ACCESS_CONTROL_MAX_AGE, Long.toString(maxAge.getSeconds()));
}

public void setAccessControlMaxAge(long maxAge)

{
    set(ACCESS_CONTROL_MAX_AGE, Long.toString(maxAge));
}

public void setAccessControlRequestHeaders(List<String> requestHeaders)

{
    set(ACCESS_CONTROL_REQUEST_HEADERS, toCommaDelimitedString(requestHeaders));
}

public void setAccessControlRequestMethod(@JavaAnnotationCall(Nullable,) HttpMethod requestMethod)

{
    setOrRemove(ACCESS_CONTROL_REQUEST_METHOD, (requestMethod != null ? requestMethod.name() : null));
}

@Override public void setAll(Map<String, String> values)

{
    this.headers.setAll(values);
}

public void setAllow(Set<HttpMethod> allowedMethods)

{
    set(ALLOW, StringUtils.collectionToCommaDelimitedString(allowedMethods));
}

public void setBasicAuth(String username, String password)

{
    setBasicAuth(username, password, null);
}

public void setBasicAuth(String username, String password, @JavaAnnotationCall(Nullable,) Charset charset)

{
    setBasicAuth(encodeBasicAuth(username, password, charset));
}

public void setBasicAuth(String encodedCredentials)

{
    Assert.hasText(encodedCredentials, "'encodedCredentials' must not be null or blank");
    set(AUTHORIZATION, "Basic " + encodedCredentials);
}

public void setBearerAuth(String token)

{
    set(AUTHORIZATION, "Bearer " + token);
}

public void setCacheControl(CacheControl cacheControl)

{
    setOrRemove(CACHE_CONTROL, cacheControl.getHeaderValue());
}

public void setCacheControl(@JavaAnnotationCall(Nullable,) String cacheControl)

{
    setOrRemove(CACHE_CONTROL, cacheControl);
}

public void setConnection(String connection)

{
    set(CONNECTION, connection);
}

public void setConnection(List<String> connection)

{
    set(CONNECTION, toCommaDelimitedString(connection));
}

public void setContentDisposition(ContentDisposition contentDisposition)

{
    set(CONTENT_DISPOSITION, contentDisposition.toString());
}

public void setContentDispositionFormData(String name, @JavaAnnotationCall(Nullable,) String filename)

{
    Assert.notNull(name, "Name must not be null");
    ContentDisposition.Builder disposition = ContentDisposition.builder("form-data").name(name);
    if (filename != null) {
        disposition.filename(filename);
    } 
    setContentDisposition(disposition.build());
}

public void setContentLanguage(@JavaAnnotationCall(Nullable,) Locale locale)

{
    setOrRemove(CONTENT_LANGUAGE, (locale != null ? locale.toLanguageTag() : null));
}

public void setContentLength(long contentLength)

{
    set(CONTENT_LENGTH, Long.toString(contentLength));
}

public void setContentType(@JavaAnnotationCall(Nullable,) MediaType mediaType)

{
    if (mediaType != null) {
        Assert.isTrue(!mediaType.isWildcardType(), "Content-Type cannot contain wildcard type '*'");
        Assert.isTrue(!mediaType.isWildcardSubtype(), "Content-Type cannot contain wildcard subtype '*'");
        set(CONTENT_TYPE, mediaType.toString());
    } else {
        remove(CONTENT_TYPE);
    }
}

public void setDate(ZonedDateTime date)

{
    setZonedDateTime(DATE, date);
}

public void setDate(Instant date)

{
    setInstant(DATE, date);
}

public void setDate(long date)

{
    setDate(DATE, date);
}

public void setDate(String headerName, long date)

{
    setInstant(headerName, Instant.ofEpochMilli(date));
}

public void setETag(@JavaAnnotationCall(Nullable,) String etag)

{
    if (etag != null) {
        Assert.isTrue(etag.startsWith("\"") || etag.startsWith("W/"), "Invalid ETag: does not start with W/ or \"");
        Assert.isTrue(etag.endsWith("\""), "Invalid ETag: does not end with \"");
        set(ETAG, etag);
    } else {
        remove(ETAG);
    }
}

public void setExpires(ZonedDateTime expires)

{
    setZonedDateTime(EXPIRES, expires);
}

public void setExpires(Instant expires)

{
    setInstant(EXPIRES, expires);
}

public void setExpires(long expires)

{
    setDate(EXPIRES, expires);
}

public void setHost(@JavaAnnotationCall(Nullable,) InetSocketAddress host)

{
    if (host != null) {
        String value = host.getHostString();
        int port = host.getPort();
        if (port != 0) {
            value = value + ":" + port;
        } 
        set(HOST, value);
    } else {
        remove(HOST, null);
    }
}

public void setIfMatch(String ifMatch)

{
    set(IF_MATCH, ifMatch);
}

public void setIfMatch(List<String> ifMatchList)

{
    set(IF_MATCH, toCommaDelimitedString(ifMatchList));
}

public void setIfModifiedSince(ZonedDateTime ifModifiedSince)

{
    setZonedDateTime(IF_MODIFIED_SINCE, ifModifiedSince.withZoneSameInstant(GMT));
}

public void setIfModifiedSince(Instant ifModifiedSince)

{
    setInstant(IF_MODIFIED_SINCE, ifModifiedSince);
}

public void setIfModifiedSince(long ifModifiedSince)

{
    setDate(IF_MODIFIED_SINCE, ifModifiedSince);
}

public void setIfNoneMatch(String ifNoneMatch)

{
    set(IF_NONE_MATCH, ifNoneMatch);
}

public void setIfNoneMatch(List<String> ifNoneMatchList)

{
    set(IF_NONE_MATCH, toCommaDelimitedString(ifNoneMatchList));
}

public void setIfUnmodifiedSince(ZonedDateTime ifUnmodifiedSince)

{
    setZonedDateTime(IF_UNMODIFIED_SINCE, ifUnmodifiedSince.withZoneSameInstant(GMT));
}

public void setIfUnmodifiedSince(Instant ifUnmodifiedSince)

{
    setInstant(IF_UNMODIFIED_SINCE, ifUnmodifiedSince);
}

public void setIfUnmodifiedSince(long ifUnmodifiedSince)

{
    setDate(IF_UNMODIFIED_SINCE, ifUnmodifiedSince);
}

public void setInstant(String headerName, Instant date)

{
    setZonedDateTime(headerName, ZonedDateTime.ofInstant(date, GMT));
}

public void setLastModified(ZonedDateTime lastModified)

{
    setZonedDateTime(LAST_MODIFIED, lastModified.withZoneSameInstant(GMT));
}

public void setLastModified(Instant lastModified)

{
    setInstant(LAST_MODIFIED, lastModified);
}

public void setLastModified(long lastModified)

{
    setDate(LAST_MODIFIED, lastModified);
}

public void setLocation(@JavaAnnotationCall(Nullable,) URI location)

{
    setOrRemove(LOCATION, (location != null ? location.toASCIIString() : null));
}

public void setOrigin(@JavaAnnotationCall(Nullable,) String origin)

{
    setOrRemove(ORIGIN, origin);
}

public void setPragma(@JavaAnnotationCall(Nullable,) String pragma)

{
    setOrRemove(PRAGMA, pragma);
}

public void setRange(List<HttpRange> ranges)

{
    String value = HttpRange.toString(ranges);
    set(RANGE, value);
}

public void setUpgrade(@JavaAnnotationCall(Nullable,) String upgrade)

{
    setOrRemove(UPGRADE, upgrade);
}

public void setVary(List<String> requestHeaders)

{
    set(VARY, toCommaDelimitedString(requestHeaders));
}

public void setZonedDateTime(String headerName, ZonedDateTime date)

{
    set(headerName, DATE_FORMATTER.format(date));
}

@Override public int size()

{
    return this.headers.size();
}

protected String toCommaDelimitedString(List<String> headerValues)

{
    StringJoiner joiner = new StringJoiner(", ");
    for (String val: headerValues) {
        if (val != null) {
            joiner.add(val);
        } 
    }
    return joiner.toString();
}

@Override public Map<String, String> toSingleValueMap()

{
    return this.headers.toSingleValueMap();
}

@Override public String toString()

{
    return formatHeaders(this.headers);
}

@Override public Collection<List<String>> values()

{
    return this.headers.values();
}

public static HttpHeaders writableHttpHeaders(HttpHeaders headers)

{
    Assert.notNull(headers, "HttpHeaders must not be null");
    if (headers == EMPTY) {
        return new HttpHeaders();
    } else if (headers instanceof ReadOnlyHttpHeaders) {
        return new HttpHeaders(headers.headers);
    } else {
        return headers;
    }
}

public static Log forLog(Log primaryLogger)

{
    return LogDelegateFactory.getCompositeLog(primaryLogger, fallbackLogger);
}

public static Log forLogName(Class<?> primaryLoggerClass)

{
    Log primaryLogger = LogFactory.getLog(primaryLoggerClass);
    return forLog(primaryLogger);
}

public boolean matches(String method)

{
    return (this == resolve(method));
}

@Nullable public static HttpMethod resolve(@JavaAnnotationCall(Nullable,) String method)

{
    return (method != null ? mappings.get(method) : null);
}

public static HttpRange createByteRange(long firstBytePos)

{
    return new ByteRange(firstBytePos, null);
}

public static HttpRange createByteRange(long firstBytePos, long lastBytePos)

{
    return new ByteRange(firstBytePos, lastBytePos);
}

public static HttpRange createSuffixRange(long suffixLength)

{
    return new SuffixByteRange(suffixLength);
}

public abstract long getRangeEnd(long length)

public abstract long getRangeStart(long length)

public static List<HttpRange> parseRanges(@JavaAnnotationCall(Nullable,) String ranges)

{
    if (!StringUtils.hasLength(ranges)) {
        return Collections.emptyList();
    } 
    if (!ranges.startsWith(BYTE_RANGE_PREFIX)) {
        throw new IllegalArgumentException("Range '" + ranges + "' does not start with 'bytes='");
    } 
    ranges = ranges.substring(BYTE_RANGE_PREFIX.length());
    String[] tokens = StringUtils.tokenizeToStringArray(ranges, ",");
    if (tokens.length > MAX_RANGES) {
        throw new IllegalArgumentException("Too many ranges: " + tokens.length);
    } 
    List<HttpRange> result = new ArrayList<>(tokens.length);
    for (String token: tokens) {
        result.add(parseRange(token));
    }
    return result;
}

public ResourceRegion toResourceRegion(Resource resource)

{
    Assert.isTrue(resource.getClass() != InputStreamResource.class, "Cannot convert an InputStreamResource to a ResourceRegion");
    long contentLength = getLengthFor(resource);
    long start = getRangeStart(contentLength);
    long end = getRangeEnd(contentLength);
    Assert.isTrue(start < contentLength, "'position' exceeds the resource length " + contentLength);
    return new ResourceRegion(resource, start, end - start + 1);
}

public static List<ResourceRegion> toResourceRegions(List<HttpRange> ranges, Resource resource)

{
    if (CollectionUtils.isEmpty(ranges)) {
        return Collections.emptyList();
    } 
    List<ResourceRegion> regions = new ArrayList<>(ranges.size());
    for (HttpRange range: ranges) {
        regions.add(range.toResourceRegion(resource));
    }
    if (ranges.size() > 1) {
        long length = getLengthFor(resource);
        long total = 0;
        for (ResourceRegion region: regions) {
            total += region.getCount();
        }
        if (total >= length) {
            throw new IllegalArgumentException("The sum of all ranges (" + total + ") should be less than the resource length (" + length + ")");
        } 
    } 
    return regions;
}

public static String toString(Collection<HttpRange> ranges)

{
    Assert.notEmpty(ranges, "Ranges Collection must not be empty");
    StringJoiner builder = new StringJoiner(", ", BYTE_RANGE_PREFIX, "");
    for (HttpRange range: ranges) {
        builder.add(range.toString());
    }
    return builder.toString();
}

Series

• INFORMATIONAL
• SUCCESSFUL
• REDIRECTION
• CLIENT_ERROR
• SERVER_ERROR

{
    int seriesCode = statusCode / 100;
    for (Series series: values()) {
        if (series.value == seriesCode) {
            return series;
        } 
    }
    return null;
}

{
    return this.value;
}

{
    return valueOf(status.value);
}

{
    Series series = resolve(statusCode);
    if (series == null) {
        throw new IllegalArgumentException("No matching constant for [" + statusCode + "]");
    } 
    return series;
}

public String getReasonPhrase()

{
    return this.reasonPhrase;
}

public boolean is1xxInformational()

{
    return (series() == Series.INFORMATIONAL);
}

public boolean is2xxSuccessful()

{
    return (series() == Series.SUCCESSFUL);
}

public boolean is3xxRedirection()

{
    return (series() == Series.REDIRECTION);
}

public boolean is4xxClientError()

{
    return (series() == Series.CLIENT_ERROR);
}

public boolean is5xxServerError()

{
    return (series() == Series.SERVER_ERROR);
}

public boolean isError()

{
    return (is4xxClientError() || is5xxServerError());
}

@Nullable public static HttpStatus resolve(int statusCode)

{
    for (HttpStatus status: values()) {
        if (status.value == statusCode) {
            return status;
        } 
    }
    return null;
}

public Series series()

{
    return Series.valueOf(this);
}

@Override public String toString()

{
    return this.value + " " + name();
}

public int value()

{
    return this.value;
}

public static HttpStatus valueOf(int statusCode)

{
    HttpStatus status = resolve(statusCode);
    if (status == null) {
        throw new IllegalArgumentException("No matching constant for [" + statusCode + "]");
    } 
    return status;
}

public InvalidMediaTypeException InvalidMediaTypeException(String mediaType, String message)

{
    super("Invalid media type \"" + mediaType + "\": " + message);
    this.mediaType = mediaType;
}

public String getMediaType()

{
    return this.mediaType;
}

public static final MediaType ALL

public static final String ALL_VALUE

public static final MediaType APPLICATION_ATOM_XML

public static final String APPLICATION_ATOM_XML_VALUE

public static final MediaType APPLICATION_CBOR

public static final String APPLICATION_CBOR_VALUE

public static final MediaType APPLICATION_FORM_URLENCODED

public static final String APPLICATION_FORM_URLENCODED_VALUE

public static final MediaType APPLICATION_JSON

@Deprecated public static final MediaType APPLICATION_JSON_UTF8

@Deprecated public static final String APPLICATION_JSON_UTF8_VALUE

public static final String APPLICATION_JSON_VALUE

public static final MediaType APPLICATION_OCTET_STREAM

public static final String APPLICATION_OCTET_STREAM_VALUE

public static final MediaType APPLICATION_PDF

public static final String APPLICATION_PDF_VALUE

public static final MediaType APPLICATION_PROBLEM_JSON

@Deprecated public static final MediaType APPLICATION_PROBLEM_JSON_UTF8

@Deprecated public static final String APPLICATION_PROBLEM_JSON_UTF8_VALUE

public static final String APPLICATION_PROBLEM_JSON_VALUE

public static final MediaType APPLICATION_PROBLEM_XML

public static final String APPLICATION_PROBLEM_XML_VALUE

public static final MediaType APPLICATION_RSS_XML

public static final String APPLICATION_RSS_XML_VALUE

public static final MediaType APPLICATION_STREAM_JSON

public static final String APPLICATION_STREAM_JSON_VALUE

public static final MediaType APPLICATION_XHTML_XML

public static final String APPLICATION_XHTML_XML_VALUE

public static final MediaType APPLICATION_XML

public static final String APPLICATION_XML_VALUE

public static final MediaType IMAGE_GIF

public static final String IMAGE_GIF_VALUE

public static final MediaType IMAGE_JPEG

public static final String IMAGE_JPEG_VALUE

public static final MediaType IMAGE_PNG

public static final String IMAGE_PNG_VALUE

public static final MediaType MULTIPART_FORM_DATA

public static final String MULTIPART_FORM_DATA_VALUE

public static final MediaType MULTIPART_MIXED

public static final String MULTIPART_MIXED_VALUE

public MediaType MediaType(String type)

{
    super(type);
}

public MediaType MediaType(String type, String subtype)

{
    super(type, subtype, Collections.emptyMap());
}

public MediaType MediaType(String type, String subtype, Charset charset)

{
    super(type, subtype, charset);
}

public MediaType MediaType(String type, String subtype, double qualityValue)

{
    this(type, subtype, Collections.singletonMap(PARAM_QUALITY_FACTOR, Double.toString(qualityValue)));
}

public MediaType MediaType(MediaType other, Charset charset)

{
    super(other, charset);
}

public MediaType MediaType(MediaType other, @JavaAnnotationCall(Nullable,) Map<String, String> parameters)

{
    super(other.getType(), other.getSubtype(), parameters);
}

public MediaType MediaType(String type, String subtype, @JavaAnnotationCall(Nullable,) Map<String, String> parameters)

{
    super(type, subtype, parameters);
}

public static final Comparator<MediaType> QUALITY_VALUE_COMPARATOR

public static final Comparator<MediaType> SPECIFICITY_COMPARATOR

public static final MediaType TEXT_EVENT_STREAM

public static final String TEXT_EVENT_STREAM_VALUE

public static final MediaType TEXT_HTML

public static final String TEXT_HTML_VALUE

public static final MediaType TEXT_MARKDOWN

public static final String TEXT_MARKDOWN_VALUE

public static final MediaType TEXT_PLAIN

public static final String TEXT_PLAIN_VALUE

public static final MediaType TEXT_XML

public static final String TEXT_XML_VALUE

public static MediaType asMediaType(MimeType mimeType)

{
    if (mimeType instanceof MediaType) {
        return (MediaType)mimeType;
    } 
    return new MediaType(mimeType.getType(), mimeType.getSubtype(), mimeType.getParameters());
}

public static List<MediaType> asMediaTypes(List<MimeType> mimeTypes)

{
    List<MediaType> mediaTypes = new ArrayList<>(mimeTypes.size());
    for (MimeType mimeType: mimeTypes) {
        mediaTypes.add(MediaType.asMediaType(mimeType));
    }
    return mediaTypes;
}

@Override protected void checkParameters(String attribute, String value)

{
    super.checkParameters(attribute, value);
    if (PARAM_QUALITY_FACTOR.equals(attribute)) {
        value = unquote(value);
        double d = Double.parseDouble(value);
        Assert.isTrue(d >= 0D && d <= 1D, "Invalid quality value \"" + value + "\": should be between 0.0 and 1.0");
    } 
}

public MediaType copyQualityValue(MediaType mediaType)

{
    if (!mediaType.getParameters().containsKey(PARAM_QUALITY_FACTOR)) {
        return this;
    } 
    Map<String, String> params = new LinkedHashMap<>(getParameters());
    params.put(PARAM_QUALITY_FACTOR, mediaType.getParameters().get(PARAM_QUALITY_FACTOR));
    return new MediaType(this, params);
}

public double getQualityValue()

{
    String qualityFactor = getParameter(PARAM_QUALITY_FACTOR);
    return (qualityFactor != null ? Double.parseDouble(unquote(qualityFactor)) : 1D);
}

public boolean includes(@JavaAnnotationCall(Nullable,) MediaType other)

{
    return super.includes(other);
}

public boolean isCompatibleWith(@JavaAnnotationCall(Nullable,) MediaType other)

{
    return super.isCompatibleWith(other);
}

public static MediaType parseMediaType(String mediaType)

{
    MimeType type;
    try {
        type = MimeTypeUtils.parseMimeType(mediaType);
    } catch (InvalidMimeTypeException ex) {
        throw new InvalidMediaTypeException(ex);
    }
    try {
        return new MediaType(type.getType(), type.getSubtype(), type.getParameters());
    } catch (IllegalArgumentException ex) {
        throw new InvalidMediaTypeException(mediaType, ex.getMessage());
    }
}

public static List<MediaType> parseMediaTypes(@JavaAnnotationCall(Nullable,) String mediaTypes)

{
    if (!StringUtils.hasLength(mediaTypes)) {
        return Collections.emptyList();
    } 
    List<String> tokenizedTypes = MimeTypeUtils.tokenize(mediaTypes);
    List<MediaType> result = new ArrayList<>(tokenizedTypes.size());
    for (String type: tokenizedTypes) {
        if (StringUtils.hasText(type)) {
            result.add(parseMediaType(type));
        } 
    }
    return result;
}

public static List<MediaType> parseMediaTypes(@JavaAnnotationCall(Nullable,) List<String> mediaTypes)

{
    if (CollectionUtils.isEmpty(mediaTypes)) {
        return Collections.emptyList();
    } else if (mediaTypes.size() == 1) {
        return parseMediaTypes(mediaTypes.get(0));
    } else {
        List<MediaType> result = new ArrayList<>(8);
        for (String mediaType: mediaTypes) {
            result.addAll(parseMediaTypes(mediaType));
        }
        return result;
    }
}

public MediaType removeQualityValue()

{
    if (!getParameters().containsKey(PARAM_QUALITY_FACTOR)) {
        return this;
    } 
    Map<String, String> params = new LinkedHashMap<>(getParameters());
    params.remove(PARAM_QUALITY_FACTOR);
    return new MediaType(this, params);
}

public static void sortByQualityValue(List<MediaType> mediaTypes)

{
    Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
    if (mediaTypes.size() > 1) {
        mediaTypes.sort(QUALITY_VALUE_COMPARATOR);
    } 
}

public static void sortBySpecificity(List<MediaType> mediaTypes)

{
    Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
    if (mediaTypes.size() > 1) {
        mediaTypes.sort(SPECIFICITY_COMPARATOR);
    } 
}

public static void sortBySpecificityAndQuality(List<MediaType> mediaTypes)

{
    Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
    if (mediaTypes.size() > 1) {
        mediaTypes.sort(MediaType.SPECIFICITY_COMPARATOR.thenComparing(MediaType.QUALITY_VALUE_COMPARATOR));
    } 
}

public static String toString(Collection<MediaType> mediaTypes)

{
    return MimeTypeUtils.toString(mediaTypes);
}

public static MediaType valueOf(String value)

{
    return parseMediaType(value);
}

@Override public String getAsText()

{
    MediaType mediaType = (MediaType)getValue();
    return (mediaType != null ? mediaType.toString() : "");
}

@Override public void setAsText(String text)

{
    if (StringUtils.hasText(text)) {
        setValue(MediaType.parseMediaType(text));
    } else {
        setValue(null);
    }
}

public static Optional<MediaType> getMediaType(@JavaAnnotationCall(Nullable,) Resource resource)

{
    return Optional.ofNullable(resource).map(Resource::getFilename).flatMap(MediaTypeFactory::getMediaType);
}

public static Optional<MediaType> getMediaType(@JavaAnnotationCall(Nullable,) String filename)

{
    return getMediaTypes(filename).stream().findFirst();
}

public static List<MediaType> getMediaTypes(@JavaAnnotationCall(Nullable,) String filename)

{
    return Optional.ofNullable(StringUtils.getFilenameExtension(filename)).map(s -> s.toLowerCase(Locale.ENGLISH)).map(fileExtensionToMediaTypes::get).orElse(Collections.emptyList());
}

@Override public void add(String headerName, @JavaAnnotationCall(Nullable,) String headerValue)

{
    throw new UnsupportedOperationException();
}

@Override public void addAll(String key, List<?> values)

{
    throw new UnsupportedOperationException();
}

@Override public void addAll(MultiValueMap<String, String> values)

{
    throw new UnsupportedOperationException();
}

@Override public void clear()

{
    throw new UnsupportedOperationException();
}

@Override public Set<Entry<String, List<String>>> entrySet()

{
    return this.headers.entrySet().stream().map(SimpleImmutableEntry::new).collect(Collectors.collectingAndThen(Collectors.toCollection(LinkedHashSet::new), Collections::unmodifiableSet));
}

@Override public List<String> get(Object key)

{
    List<String> values = this.headers.get(key);
    return (values != null ? Collections.unmodifiableList(values) : null);
}

@Override public List<MediaType> getAccept()